{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy 是 Python 中科学计算的核心库。它提供了一个高性能的多维数组对象，以及用于处理这些数组的工具。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 数组（Arrays）\n",
    "numpy 数组是一个值网格，所有类型都相同，并由非负整数元组索引。维数是数组的排名；数组的形状是一个整数元组，给出了每个维度的数组大小。\n",
    "\n",
    "我们可以从嵌套的 Python 列表初始化 numpy 数组，并使用方括号访问元素："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "(3,)\n",
      "1 2 3\n",
      "[5 2 3]\n",
      "(2, 3)\n",
      "1 2 4\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "a = np.array([1, 2, 3])\n",
    "print(type(a))\n",
    "print(a.shape)\n",
    "print(a[0], a[1], a[2])\n",
    "a[0] = 5\n",
    "print(a)\n",
    "\n",
    "b = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "print(b.shape)\n",
    "print(b[0, 0], b[0, 1], b[1, 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0.]\n",
      " [0. 0.]]\n",
      "[[1. 1.]]\n",
      "[[7 7]\n",
      " [7 7]]\n",
      "[[1. 0.]\n",
      " [0. 1.]]\n",
      "[[0.76123235 0.17671343]\n",
      " [0.2039839  0.4767574 ]]\n"
     ]
    }
   ],
   "source": [
    "# NumPy 创建数组的函数\n",
    "a = np.zeros((2, 2))\n",
    "print(a)\n",
    "\n",
    "b = np.ones((1, 2))\n",
    "print(b)\n",
    "\n",
    "c = np.full((2, 2), 7)\n",
    "print(c)\n",
    "\n",
    "d = np.eye(2)\n",
    "print(d)\n",
    "\n",
    "e = np.random.random((2, 2))\n",
    "print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 数组索引\n",
    "NumPy 提供了几种索引数组的方法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 切片（Slicing）\n",
    "与 Python 列表类似，可以对 numpy 数组进行切片。由于数组可能是多维的，因此必须为数组的每个维指定一个切片："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n",
      "[[2 3]\n",
      " [6 7]]\n",
      "2\n",
      "77\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])\n",
    "b = a[:2, 1:3]\n",
    "print(a)\n",
    "print(b)\n",
    "print(a[0, 1])\n",
    "b[0, 0] = 77\n",
    "print(a[0, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 6 7 8] (4,)\n",
      "[[5 6 7 8]] (1, 4)\n",
      "[ 2  6 10] (3,)\n",
      "[[ 2]\n",
      " [ 6]\n",
      " [10]] (3, 1)\n"
     ]
    }
   ],
   "source": [
    "# 可以将整数索引与切片混合使用\n",
    "# 但是，这样做会产生比原始数组更低级别的数组\n",
    "a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])\n",
    "row_r1 = a[1, :]\n",
    "row_r2 = a[1:2, :]\n",
    "print(row_r1, row_r1.shape)\n",
    "print(row_r2, row_r2.shape)\n",
    "\n",
    "col_r1 = a[:, 1]\n",
    "col_r2 = a[:, 1:2]\n",
    "print(col_r1, col_r1.shape)\n",
    "print(col_r2, col_r2.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 整数数组索引\n",
    "使用切片索引到 numpy 数组时，生成的数组视图将始终是原始数组的子数组。\n",
    "相反，整数数组索引允许你使用另一个数组中的数据构造任意数组。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 4 5]\n",
      "[1 4 5]\n",
      "[2 2]\n",
      "[2 2]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1, 2], [3, 4], [5, 6]])\n",
    "print(a[[0, 1, 2], [0, 1, 0]])\n",
    "print(np.array([a[0, 0], a[1, 1], a[2, 0]]))\n",
    "print(a[[0, 0], [1, 1]])\n",
    "print(np.array([a[0, 1], a[0, 1]]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3]\n",
      " [ 4  5  6]\n",
      " [ 7  8  9]\n",
      " [10 11 12]]\n",
      "[ 1  6  7 11]\n",
      "[[11  2  3]\n",
      " [ 4  5 16]\n",
      " [17  8  9]\n",
      " [10 21 12]]\n"
     ]
    }
   ],
   "source": [
    "# 整数数组索引的一个有用技巧是从矩阵的每一行中选择或改变一个元素：\n",
    "a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])\n",
    "print(a)\n",
    "\n",
    "b = np.array([0, 2, 0, 1])\n",
    "print(a[np.arange(4), b])\n",
    "\n",
    "a[np.arange(4), b] += 10\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 布尔数组索引\n",
    "布尔数组索引允许你选择数组的任意元素。\n",
    "通常，这种类型的索引用于选择满足某些条件的数组元素。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[False False]\n",
      " [ True  True]\n",
      " [ True  True]]\n",
      "[3 4 5 6]\n",
      "[3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1, 2], [3, 4], [5, 6]])\n",
    "bool_idx = (a > 2)\n",
    "print(bool_idx)\n",
    "print(a[bool_idx])\n",
    "print(a[a > 2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 数据类型\n",
    "每个 numpy 数组都是相同类型元素的网格。NumPy 提供了一组可用于构造数组的大量数值数据类型。NumPy 在创建数组时尝试猜测数据类型，但构造数组的函数通常还包含一个可选参数来显式指定数据类型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int32\n",
      "float64\n",
      "int64\n"
     ]
    }
   ],
   "source": [
    "x = np.array([1, 2])\n",
    "print(x.dtype)\n",
    "\n",
    "x = np.array([1.0, 2.0])\n",
    "print(x.dtype)\n",
    "\n",
    "x = np.array([1, 2], dtype = np.int64)\n",
    "print(x.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 数组中的数学\n",
    "基本数学函数在数组上以元素方式运行，既可以作为运算符重载，也可以作为 numpy 模块中的函数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 6.  8.]\n",
      " [10. 12.]]\n",
      "[[ 6.  8.]\n",
      " [10. 12.]]\n",
      "[[-4. -4.]\n",
      " [-4. -4.]]\n",
      "[[-4. -4.]\n",
      " [-4. -4.]]\n",
      "[[ 5. 12.]\n",
      " [21. 32.]]\n",
      "[[ 5. 12.]\n",
      " [21. 32.]]\n",
      "[[0.2        0.33333333]\n",
      " [0.42857143 0.5       ]]\n",
      "[[0.2        0.33333333]\n",
      " [0.42857143 0.5       ]]\n",
      "[[1.         1.41421356]\n",
      " [1.73205081 2.        ]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1, 2], [3, 4]], dtype = np.float64)\n",
    "y = np.array([[5, 6], [7, 8]], dtype = np.float64)\n",
    "\n",
    "print(x + y)\n",
    "print(np.add(x, y))\n",
    "\n",
    "print(x - y)\n",
    "print(np.subtract(x, y))\n",
    "\n",
    "print(x * y)\n",
    "print(np.multiply(x, y))\n",
    "\n",
    "print(x / y)\n",
    "print(np.divide(x, y))\n",
    "\n",
    "print(np.sqrt(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\* 是元素乘法，而不是矩阵乘法。我们使用 **dot** 函数来计算向量的内积，将向量乘以矩阵。\n",
    "**dot** 既可以作为 numpy 模块中的函数，也可以作为数组对象的实例方法。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "219\n",
      "219\n",
      "[29 67]\n",
      "[29 67]\n",
      "[[19 22]\n",
      " [43 50]]\n",
      "[[19 22]\n",
      " [43 50]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1, 2], [3, 4]])\n",
    "y = np.array([[5, 6], [7, 8]])\n",
    "\n",
    "v = np.array([9, 10])\n",
    "w = np.array([11, 12])\n",
    "\n",
    "print(v.dot(w))\n",
    "print(np.dot(v, w))\n",
    "\n",
    "print(x.dot(v))\n",
    "print(np.dot(x, v))\n",
    "\n",
    "print(x.dot(y))\n",
    "print(np.dot(x, y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "[4 6]\n",
      "[3 7]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1, 2], [3, 4]])\n",
    "\n",
    "print(np.sum(x))\n",
    "print(np.sum(x, axis = 0))\n",
    "print(np.sum(x, axis = 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n",
      "[[1 3]\n",
      " [2 4]]\n",
      "[1 2 3]\n",
      "[1 2 3]\n"
     ]
    }
   ],
   "source": [
    "# 转置一个矩阵，需要使用一个数组对象的 **T** 属性：\n",
    "x = np.array([[1, 2], [3, 4]])\n",
    "print(x)\n",
    "\n",
    "print(x.T)\n",
    "\n",
    "v = np.array([1, 2, 3])\n",
    "print(v)\n",
    "print(v.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 广播（Broadcasting）\n",
    "广播是一种强大的机制，它允许 numpy 在执行算法运算时使用不同形状的数组。\n",
    "通常，我们有一个较小的数组和一个较大的数组，我们希望多次使用较小的数组来对较大的数组执行一些操作。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  2  4]\n",
      " [ 5  5  7]\n",
      " [ 8  8 10]\n",
      " [11 11 13]]\n"
     ]
    }
   ],
   "source": [
    "# 假设要向矩阵的每一行添加一个常数向量\n",
    "x = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])\n",
    "v = np.array([1, 0, 1])\n",
    "y = np.empty_like(x)\n",
    "\n",
    "for i in range(4):\n",
    "    y[i, :] = x[i, :] + v\n",
    "\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 0 1]\n",
      " [1 0 1]\n",
      " [1 0 1]\n",
      " [1 0 1]]\n",
      "[[ 2  2  4]\n",
      " [ 5  5  7]\n",
      " [ 8  8 10]\n",
      " [11 11 13]]\n"
     ]
    }
   ],
   "source": [
    "# 当矩阵 x 非常大时，在 Python 中计算显式循环可能会很慢\n",
    "# 向矩阵 x 的每一行添加向量 v 等同于通过垂直堆叠多个 v 副本来形成矩阵 vv\n",
    "# 然后执行元素的求和 x 和 vv。\n",
    "\n",
    "x = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])\n",
    "v = np.array([1, 0, 1])\n",
    "vv = np.tile(v, (4, 1))\n",
    "print(vv)\n",
    "\n",
    "y = x + vv\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  2  4]\n",
      " [ 5  5  7]\n",
      " [ 8  8 10]\n",
      " [11 11 13]]\n"
     ]
    }
   ],
   "source": [
    "# NumPy 广播允许我们在不实际创建 v 的多个副本的情况下执行此计算\n",
    "x = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])\n",
    "v = np.array([1, 0, 1])\n",
    "y = x + v\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "将两个数组一起广播遵循以下规则：\n",
    "\n",
    "- 1、如果数组不具有相同的 rank，则将较低等级数组的形状添加 1，直到两个形状具有相同的长度。\n",
    "\n",
    "- 2、如果两个数组在维度上具有相同的大小，或者如果其中一个数组在该维度中的大小为 1，则称这两个数组在维度上是兼容的。\n",
    "\n",
    "- 3、如果数组在所有维度上兼容，则可以一起广播。\n",
    "\n",
    "- 4、广播之后，每个阵列的行为就好像它的形状等于两个输入数组的形状的元素最大值。\n",
    "\n",
    "- 5、在一个数组的大小为 1 且另一个数组的大小大于 1 的任何维度中，第一个数组的行为就像沿着该维度复制一样。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 4  5]\n",
      " [ 8 10]\n",
      " [12 15]]\n",
      "[[2 4 6]\n",
      " [5 7 9]]\n",
      "[[ 5  6  7]\n",
      " [ 9 10 11]]\n",
      "[[ 5  6  7]\n",
      " [ 9 10 11]]\n",
      "[[ 2  4  6]\n",
      " [ 8 10 12]]\n"
     ]
    }
   ],
   "source": [
    "v = np.array([1, 2, 3])\n",
    "w = np.array([4, 5])\n",
    "print(np.reshape(v, (3, 1)) * w)\n",
    "\n",
    "x = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "print(x + v)\n",
    "\n",
    "print((x.T + w).T)\n",
    "print(x + np.reshape(w, (2, 1)))\n",
    "print(x * 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "广播通常会使得代码更简洁、效率更高，所以要尽可能地使用它"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SciPy\n",
    "NumPy 提供了一个高性能的多维数组和基本工具来计算和操作这些数组。\n",
    "而 SciPy 以此为基础，提供了大量在 numpy 数组上运行的函数，可用于不同类型的科学和工程应用程序。\n",
    "\n",
    "[SciPy 官方文档](https://docs.scipy.org/doc/scipy/reference/index.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 图像操作\n",
    "SciPy 提供了一些处理图像的基本函数，具有将映像从磁盘读入 numpy 数组、将 numpy 数组作为映像写入磁盘以及调整映像大小的功能。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "uint8 (400, 248, 3)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Programma\\Anaconda3\\lib\\site-packages\\skimage\\transform\\_warps.py:105: UserWarning: The default mode, 'constant', will be changed to 'reflect' in skimage 0.15.\n",
      "  warn(\"The default mode, 'constant', will be changed to 'reflect' in \"\n",
      "D:\\Programma\\Anaconda3\\lib\\site-packages\\skimage\\transform\\_warps.py:110: UserWarning: Anti-aliasing will be enabled by default in skimage 0.15 to avoid aliasing artifacts when down-sampling images.\n",
      "  warn(\"Anti-aliasing will be enabled by default in skimage 0.15 to \"\n",
      "WARNING:root:Lossy conversion from float64 to uint8. Range [0.0, 255.0]. Convert image to uint8 prior to saving to suppress this warning.\n"
     ]
    }
   ],
   "source": [
    "import imageio\n",
    "import skimage\n",
    "\n",
    "img = imageio.imread('assets/cat.jpg')\n",
    "print(img.dtype, img.shape)\n",
    "\n",
    "img_tinted = img * [1, 0.95, 0.9]\n",
    "img_tinted = skimage.transform.resize(img_tinted, (300, 300))\n",
    "\n",
    "imageio.imwrite('assets/cat_tinted.jpg', img_tinted)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matplotlib\n",
    "Matplotlib 是一个绘图库， matplotlib.pyplot 模块，提供了类似于 MATLAB 的绘图系统"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 绘制\n",
    "matplotlib 中最重要的功能是 plot，它允许你绘制 2D 数据的图像。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "x = np.arange(0, 3 * np.pi, 0.1)\n",
    "y = np.sin(x)\n",
    "\n",
    "plt.plot(x, y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 通过一些额外的工作，我们可以轻松地一次绘制多条线，并添加标题，图例和轴标签\n",
    "x = np.arange(0, 3 * np.pi, 0.1)\n",
    "y_sin = np.sin(x)\n",
    "y_cos = np.cos(x)\n",
    "\n",
    "plt.plot(x, y_sin)\n",
    "plt.plot(x, y_cos)\n",
    "plt.xlabel('x axis label')\n",
    "plt.ylabel('y axis label')\n",
    "plt.title('Sine and Cosine')\n",
    "plt.legend(['Sine', 'Cosine'])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 子图\n",
    "使用 **subplot** 函数在同一个图中绘制不同的东西。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXYAAAEICAYAAABLdt/UAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3Xlc1NX+x/HXYdh3BRQFARcUFJXNNbPF6mpammkuaVp2LVtt35fbdrvtanbLLc1Ms8wsK63MSssNBBTFBcEFUQERkH07vz/A+7N7M7dhvrN8no+Hj4fAMPOeQd6e75nv9xyltUYIIYT9cDI6gBBCCPOSYhdCCDsjxS6EEHZGil0IIeyMFLsQQtgZKXYhhLAzUuzCYSmlblZKfW90DiHMTcl57MLeKaX6Aa8BXYA6IAOYqrXeYmgwIZqIs9EBhGhKSilfYCUwBVgKuAKXAlVG5hKiKclUjLB3HQG01ou11nVa6wqt9fda621KqYlKqfWnbqiU0kqpO5VSe5VSJ5RSM5VS6rSv36aUymj82mqlVLgRT0iIs5FiF/ZuD1CnlFqglBqklGp2ltsPAXoA3YGbgL8BKKWGAU8Cw4EgYB2wuMlSC3ERpNiFXdNalwD9AA3MBvKVUl8ppVqe4Vte1VoXaa0PAmuB2MbP3wH8U2udobWuBV4BYmXULqyRFLuwe41lPFFrHQrEAK2Bd85w86On/b0c8G78ezgwTSlVpJQqAgoBBYQ0UWwhLpgUu3AoWutdwHwaCv58HALu0Fr7n/bHQ2v9u9lDCnGRpNiFXVNKRSmlHlJKhTZ+3AYYA2w8z7t6H3hCKdWl8X78lFIjzZtWCPOQYhf27iTQC9iklCqjodDTgYfO50601suBfwFLlFIljfcxyMxZhTALuUBJCCHsjIzYhRDCzkixCyGEnZFiF0IIOyPFLoQQdsaQRcACAwN1RESEEQ8thBA2Kzk5uUBrHXS22xlS7BERESQlJRnx0EIIYbOUUgfO5XZmmYpRSs1TSuUppdLNcX9CCCEunLnm2OcDA810X0IIIS6CWaZitNa/KqUizHFf9qaiuo6kA4XsPnqSvcdKycwvpaSihuq6eqpr6/FwMRHs506wnzsRAV70iGhOXJg/7i4mo6MLYXEHjpexYd9xsgrKyC4o4+Dxcipr69AaNBofNxfCmnsSFuBJhyBv+nYIILSZp9GxrY7F5tiVUpOByQBhYWGWelhDFFfUsCr9CD/szGN9Zj6VNfUABHi50qGFN+2DvHFzccLV5ER5dR1HiivYuO84y1MOozW4OjsRH+bP0NgQhnRrhY+7i8HPSIimobUm+cAJvk7L5Zc9+ew/Xg40/A6EN/ckPMALLzcTClBKUVRezd68k/y0O4/q2obfq3aBXvTvGMSIhFBiQvwMfDbWw2xLCjSO2Fdqrc+6al5iYqK2xzdP9+WXMv+3/SzbmkN5dR0h/h5cFd2CK6Ja0DXEjwBvt7/8/uLyGrbsL2RT9nHW7s4nM68Udxcnru3aikn92tKltfyjFfahvLqWL1NyWbjxABlHSvBwMdGnfQCXdQyiX2QgEQFemJzUGb+/vl6TmV/Kur0FrN+bz+/7jlNVW0/3UD/G9gpjaGyIXR71KqWStdaJZ72dFPvF219Qxqvf7WLVjqO4mpy4PrY1E/pEEBPiy2k7q50XrTVpOcUsTTrEV6m5lFbVcm3XYB64qiORLX3M/AyEsIyaunqWbD7ItDV7KSitJrqVL7f0CWdobGs8XS98AqG4ooblW3P4ZPNB9hwrpZWfOw9c1ZHh8SE4m+znch0pdgsorqhhxpq9LNiwH1eTE5P6tWV8nwiCfP56ZH4hjzN3XRbzfttPWXUtIxNCefLaaPw9Xc36OEI0pdU7jvLqd7vILiijZ9vmPHxNJ3pENLvgwc+f0Vrz+77jvLZ6N2mHiujQwpunB0dzeacWZnsMI1m02JVSi4HLgUDgGPCc1nrumW5vD8X+w85jPPHFNo6XVTMyIZSHr+lEC1/3Jn3ME2XVvPdzJvN+208zTxeev74Lg7u2MusvhhDmdry0imdWpPPt9qNEtvDm8UFRXBnVokn/3WqtWZV+lNdX7yaroIwb40N5dkhn/Dxt+/0qi4/Yz4ctF/vJyhpeXLmTpUk5dG7ly2sjuln8DZsducU8vmw72w8Xc3Xnlrx2YzeaecnoXVif77Yf4ekv0zlZWcvUqyOZfGk7i06NVNXWMWNNJv/+ZR8BXq78c3hXBkSfabtb6yfF3gS25xQzZVEyuUUVTLm8PfcP6IirszHzd7V19cz7LZvXV++mhY87746NIy6smSFZhPhv1bX1vLByBx9vPEjXED/evKk7HQ18byj9cDEPf5bGrqMnueOydjxyTSebnHuXYjez5Sk5PL5sO4HebkwfE0tCeHOjIwGQdqiIuxZtJe9kJU9eG83EvhEyNSMMdbS4kimLkkk5WGRVJVpVW8cLX+9k0aaD9GkXwPQxcWZ/P6ypSbGbSW1dPa9+t4s567Pp3a45M8fGn/W0RUsrLq/hoc9S+TEjjzE92/Di0Bir+EUSjif5wAnuWJhERXUdr4/szrVdWxkd6X8sS87hyeXbaebpytyJiTZ1GvG5Frv89v+Fypo67vw4mTnrs5nYN4KFk3pZXakD+Hm6MPuWRO65ogOLNx9i0oIkSqtqjY4lHMwPO48xdvZGvN2c+fLuS6yy1AFuTAjli7v6ohSM+mAjv2UWGB3J7KTYz6C4oobxczexZlceLw7twvPXd8HFikfBSike/lsn/jm8K+szCxj5/gbySiqNjiUcxOLNB7ljYRJRwT4sm9LX6q+16NLajy/u6kuIvwcTP9zMlymHjY5kVtbbVAbKK6lk1AcbSD1UxIwxcYzvE2F0pHM2pmcYcyckcuB4GaNmbeRIcYXRkYSde/envTzxxXb6dwxi8eTeVnlU+2da+Xmw9M4+JIQ3Y+qnqSz4fb/RkcxGiv2/HCupZNSsjRwsLGfexB4M6dba6Ejn7fJOLVg4qScFJ6u46YMNHCosNzqSsFPv/LiHN77fw/C4EGbfknhRV48awc/DhQW39eSazi157qsdzFufbXQks5BiP03eyUrGzN5IXkklCyf15NLIs25UYrUSwpvz8e29KC6vYfSsjRw4XmZ0JGFn3vlxD+/8uJcRCaG8PrK7VU9V/hU3ZxMzb45nYJdgXli5kznrsoyOdNFs8yfRBPJPVjF29iaOFlcy/7aeVnM648Xo3safT/7em/LqWsbO3iTTMsJspv249z+l/q8bu/3lgl22wMXkxIyxcVzbNZiXvsmw+XKXYqfhdMFxczZx+EQF8yb2oEeE7Zf6KTEhfiyc1IuSiobneLy0yuhIwsbNW5/N2z/u4cZ4+yj1U1xMTkwb/f/l/lnSIaMjXTCHL/bKmjomLdhCdkEZcyYk0rtdgNGRzC4mxI85ExLJOVHBhA83U1JZY3QkYaO+TDnMCyt3MrBLMK+NsJ9SP8XF5MTbo2K5NDKQx7/Yzvc7jhod6YI4dLHX1tVzzycpJB88wVujunNJh0CjIzWZXu0CeH9cAruOnOTvC5Koqq0zOpKwMWt35/HwZ2n0aRfAO6Nj7a7UT3FzNvH+uARiQvy4Z3EKG/YdNzrSeXPYYtda8/SX6fyYcYznr+tik2e/nK8rolrw5k3d2ZRdyKOfb6O+3vJXHQvblHaoiCkfJxPVyodZtyTY5SYWp/Nyc2b+xB6EN/dk8kdJ7Dl20uhI58Vhi/29n/exZMsh7rmiAxP6Rhgdx2KGxobw6MBOrEjN5a0f9hgdR9iAnBPlTFqQRJCPG/Nv7ekwWzU283Jl/m09cXc1ceuHW8g/aTvvTzlksX+z7Qivr97NsNjWPHRNR6PjWNyUy9ozpmcb3l2byZLNB42OI6xYSWUNk+Y3TN19OLEHgTZy8ZG5hPh7MHdCIsfLqrj9o4Y1cGyBwxV72qEiHlyaSkJ4M169sZtDroSolOKFoTH07xjEU1+m87sdrpUhLt6p96D25Zfy/rgEOrSw7mUCmkq3UH+mjY5jW04RD3yaahNTmA5V7LlFFdz+UcMh5Qfj7X+e8K+4mJyYOTaOdoFe3PXJVg4el6tTxR+99E0Gv+7J56VhMXZ9YsG5+FuXYJ66NppVO47yzpq9Rsc5K4cp9sqaOu5YmExFdR3zHPCQ8s/4uDesCqk1/P0jWRFS/L+lSYeY//t+JvVry+ieYUbHsQqT+rVlREIo09fsZVX6EaPj/CWHKHatNU8tT2f74WLeHhVr6E4u1iYi0It3x8axN++kzRxmiqaVcvAETy9P55IOATwxKMroOFZDKcVLw2KIbePPg0vT2HW0xOhIZ+QQxb7g9/0s25rD/QMiubqz7e532FQujQziqcGd+WHnMab/ZP2HmaLp5JVUcufHybT0c+PdMfGyYct/cXcx8cH4BLzdnPn7R0mcKKs2OtKfsvuf2qas47z4TQZXRbfk/gGRRsexWrddEsENcSFMW7OXn3fnGR1HGKCmrp67Fm2lpKKWWeMTZYP0M2jp68774xM4VlzFVCs9yrXrYs8rqeTuT1IID/DkrVHdcbLTK+XMQSnFKzd0pVNLH+5fkipL/TqgV7/bRdKBE/xrRDeiW/kaHceqxYc149nrOvPLnnyrPMq122I/dapWWVUt749LwNdBLqq4GB6uDZdS12vNlEXJVNbYxjm74uJ9s+0Icxu3gLy+u/1fhW0ON/cKY3i8dR7l2m2xv/79bjbvL+Sfw7vKm6XnISLQi7dviiX9cAnPf7XD6DjCAvbll/Lo52nEhfnz5LXRRsexGUopXh7WcJQ79dNUck5Yz1GuXRb79zuO8sEvWYzrHcawuBCj49icqzq35K7L27NkyyGWp+QYHUc0oYrqOqZ8nIybi4n3bo7H1dkuK6HJnDrKravT3P1JCtW19UZHAuyw2A8VlvPQZ2l0C/XjmSGdjY5jsx68uiM92zbnqeXpZOaVGh1HNJHnvkpnb14p74yKpZWfh9FxbFJEoBevjehG2qEi/rVql9FxADsr9uraeu5ZnALAzLHxuDk77pWlF8vZ5MSMMXF4uJi4e9FWm1kjQ5y7L7bmsDQph3uu6ED/jra7DaQ1GNS1FRP7RjB3fbZVrOFuV8X+2qpdpB0q4vUR3WjT3NPoODavpa87b4+KZU/eSZ77Kt3oOMKMMvNO8tTydHq2bS6nAZvJE9dG0TXEj4c/SzP8rDK7KfYfdx5jzvpsJvQJZ2BMK6Pj2I3+HYO4+/IOLE3KYUXqYaPjCDOorKnj7kUpeLiamD46Ti5CMhM3ZxMzx8ajNdy7OIWaOuPm2+3iJ5pbVMHDn6fRpbUvT8i7+mY39apIEsOb8dTydPYXlBkdR1ykF1buZPexk7x1U3eC/dyNjmNXwgI8efXGbqQeKuLN743b78Dmi72uXjN1SSo1tfW8OzbeoVdsbCrOJiemjYnD5KS4d7H1vPMvzt9324/wyaaD3NG/HZd3amF0HLs0uFsrxvQM4/1f9vHrnnxDMth8sc/4aS+b9xfy4rAY2gZ6GR3HboX4e/DaiG5sP1xsNe/8i/OTc6Kcx5Zto3uoHw9d08noOHbt2SGd6djSmweXphmy85JNF/vm7EKmr9nL8LgQhseHGh3H7v2tSzAT+oQzd302a63sSjvx12rr6pm6JJV6DTPGyPnqTc3D1cSMMfGcrKzhwaWWX0/GZn+6ReXVTF2SQlhzT14YFmN0HIfxxLXRRAX78PDSNPJOVhodR5yj6Wv2knTgBC/fEENYgJwxZgmdgn149rrOrNtbwJz1WRZ9bJssdq01jy/bTn5pFTPGxOPt5mx0JIfh7mJixpg4yqpreWhpmlWubCf+aGPWcd5dm8nIhFCGxsqV2JY0tmcYA7sE8/rq3WzPKbbY49pksS/efIhVO47y6N+i6BrqZ3QchxPZ0odnhhgzEhHnp6i8mgc+TSU8wIvnr+9idByHo5Ti1Ru7Eujtxn1LGhYltASzFLtSaqBSardSKlMp9bg57vNM9h47yQsrd3BpZCCT+rVtyocSf+HUSOS1VbvZllNkdBzxJ7TWPLZsGwWlVUwfHYeXHNkawt/TlbdHxbL/eBnPWWhhvYsudqWUCZgJDAI6A2OUUk2ySEtlTR33Lk7By9WZN2+S9dWNdGokEuTjxn2LU2S/VCv0yeaDrN5xjEf+1kmObA3Wu10A91zRgc+Tc1htgSUHzDFi7wlkaq2ztNbVwBJgqBnu93+8tmo3u46e5I2R3WnhIxdWGO3USORAYbks8Wtl9h47yYsrd3JpZCC392tndBwB3D8gkscGRnFpZGCTP5Y5ij0EOHTaxzmNn/sDpdRkpVSSUiopP//CTtq/tmswj/ytE1dEyYUV1uL0kchXablGxxH8/5Gtp6szb46UI1tr4WxyYsrl7fF0bfopMXMU+5/9q/mfUyW01rO01ola68SgoAtbSS4xojl3X9Hhgr5XNJ37BkQSF+bPU19sN3zxIwH/WrWr8ci2Gy185cjWEZmj2HOANqd9HArI0M2BuJicmD46DoD7l6RQa+DiR45u7a48PvxtPxP7RnBlVEuj4wiDmKPYtwCRSqm2SilXYDTwlRnuV9iQNs09eemGGLYeLGLaGuvb3NcR5JVU8vBnaUQF+/D4oCij4wgDXXSxa61rgXuA1UAGsFRrLe+kOaChsSGMSAjl3bWZbNh33Og4DqW+XvPg0jTKqmuZMSZOFsNzcGY5j11r/a3WuqPWur3W+mVz3KewTf+4vgsRAV488GkqJ8qqjY7jMD74NYv1mQU8d10XImXzdodnk1eeCuvl5ebMjDFxHC+r4tFl29BalhxoaikHT/Dm97sZ3LUVo3u0Ofs3CLsnxS7MLibEj8cGRvHDzmN8tOGA0XHsWkllDfctSaGlrzuvDO+KUnJqo5BiF01kUr+2XBnVgpe/ySD9sOUWP3IkWmue+GI7uUWVTB8Ti5+Hi9GRhJWQYhdNQinFGyO708zLhXtlyYEm8cnmg3yz7QgPXdORhPDmRscRVkSKXTSZ5l6uTBsdx4HjZTzzZbrMt5tRxpESXvi6YcmAO/u3NzqOsDJS7KJJ9W4XwH0DIlmecpjPknKMjmMXyqtrueeTrfh6uPD2qFhZMkD8Dyl20eTuvTKSSzoE8MyKdDKOlBgdx6ZprXlqeTpZBWVMGxVLoLeb0ZGEFZJiF03O5KR4Z1Qcfh4u3L1oq8y3X4TFmw+xPOUwUwd0pG+Hpl8lUNgmKXZhEUE+bkwfE8f+42U88cV2mW+/AOmHi3n+qx307xjEvVfKYnjizKTYhcX0bhfAQ9d04uu0XBb8vt/oODaluKKGKYuSCfB25R2ZVxdnIcUuLGrKZe25KroFL32TwZb9hUbHsQn19ZqHlqZypKiSd8fG09zL1ehIwspJsQuLcnJSvHlTLKHNPLhr0VbySiqNjmT1ZvyUyY8ZeTw9OJqE8GZGxxE2QIpdWJyfhwvvj0+gtLKWuz/ZSo2s335GazKO8faPexgeH8KEvhFGxxE2QopdGCIq2JdXb+zKlv0neHHlTqPjWKXsgjKmfppKTIgvr9wg68CIc9f0m+8JcQZDY0NIP1zM7HXZdAr24eZe4UZHshollTVM/igJZyfF++MSZH11cV5kxC4M9figaC7vFMRzK3bI5hyNauvqufeTFLILynjv5gRCm3kaHUnYGCl2YSiTk2L6mDjCAzy5a1EyB4/LZtgvf5vBL3vyeWlYDH3aBxgdR9ggKXZhOF93F+ZM6EG9htsWbKG4vMboSIZZtOkAH/62n0n92jK6Z5jRcYSNkmIXVqFtoBfvj0vg4PFyJi9Moqq2zuhIFrd2dx7PrtjBFZ2CePLaaKPjCBsmxS6sRp/2Abw+shubsgt5+LNt1Nc7zrIDaYeKuOvjrUQF+zB9TBwmubJUXAQ5K0ZYlaGxIeQWVfKvVbto7efOEw4wct1fUMZt87cQ6OPKh7f2wMdddkISF0eKXVidOy9rR25RBR/8moW/pytTLrffjSTyTlZyy7zNaGDBrT1p4eNudCRhB6TYhdVRSvH89V0oqazhX6t24eVm4pY+EUbHMrvjpVXcPHsTBaVVLLq9F+2CvI2OJOyEFLuwSianhj1Ty6vreHbFDjxdnRmREGp0LLMpKq9m3NzNHCwsZ/6tPYkLkzVghPnIm6fCarmYnJgxJo5+HQJ59PM0lqfYx9Z6JZU13DJvM/vySpl9S6Kcqy7MTopdWDV3FxOzbkmgd7sAHlyaxiebDhod6aIcL61i7OyNZBwp4d/j4unfMcjoSMIOSbELq+fp6sy8iT24vGMQTy7fztz12UZHuiBHiiu46YMN7D1WygfjExgQ3dLoSMJOSbELm+DuYuKD8YkMignmxZU7eWP1bps6zz27oIwR/95AXkkVCyf14sooKXXRdKTYhc1wdW6Ycx+V2IZ312Zy35IUKmus/wrVDfuOM/y936ioqWPx5N70bNvc6EjCzslZMcKmOJucePXGrrQN8uLV73ZxuKiC2bckEujtZnS0P7Vo0wGeW7GD8ABP5k7oQUSgl9GRhAOQEbuwOUop7rysPf++OZ6MIyUMmb6eTVnWteRvZU0dz3yZzlPL0+kXGcjyuy+RUhcWI8UubNagrq34/M6+eLiaGDN7IzPW7KXOCubddx89ybCZv7Fw4wEm92/H3Ak98JVlAoQFSbELmxYT4sfX9/bjuu6tefOHPdw8ZyNZ+aWGZKmv18z/LZvr3l1PQWkVH07swZPXRsuCXsLilNaWH+EkJibqpKQkiz+usF9aaz5LzuHFlTupqqlnyuXtmXJ5e4ttKZd6qIjnvtpB2qEirugUxGsjuhPkY53z/sJ2KaWStdaJZ7udvHkq7IJSipsS23B5pyBeWpnBtDV7WZF6mKlXdWRIt1Y4m5rm4PRIcQVvfb+Hz5JzCPJx482R3RkeHyIbTwtDyYhd2KV1e/N5aWUGu4+dpG2gF3dd3p7rY1vj5myeEfyuoyXM+jWLr1JzUQpuu6Qt9w6IxNtNxkqi6ZzriP2iil0pNRJ4HogGemqtz6mtpdiFJdTXa77feYzpa/ay80gJvu7ODO7WmuHxISSENcPpPOe+j5VUsir9KN9uP8Km7EI8XEyM6tGGSf3a0qa5bDgtmp6lij0aqAc+AB6WYhfWSGvNur0FLE85zKr0o1TU1OHn4UJcmD8JYc2IbuVLoI8bAV6u+Lq7UF5TS1lVLUXlNew6epKdR0pIP1zMtpxiACJbeDM0tjU39wqnmZerwc9OOBKLzLFrrTMaH+xi7kaIJqWUon/HIPp3DOKlYbX8mHGMDfuOk3zgBD/vzj/r9/u6O9O5tS8PXt2RQTHBRLb0sUBqIS6cxSYElVKTgckAYWGy+7owhpebM0NjQxgaGwJAcXkN2cfLKCyroqC0mpOVtXi6mvByc8bH3ZkOQd6ENvOQwYuwKWctdqXUj0Dwn3zpKa31inN9IK31LGAWNEzFnHNCIZqQn6cLsZ7+RscQwqzOWuxa66ssEUQIIYR5yJWnQghhZy72rJgbgBlAEFAEpGqt/3YO35cPHLjAhw0ECi7we+2FvAbyGjj68wfHfA3CtdZn3XbLkAuULoZSKulcTvexZ/IayGvg6M8f5DX4KzIVI4QQdkaKXQgh7IwtFvssowNYAXkN5DVw9OcP8hqckc3NsQthKUqpHcDdWuufjc4ixPmwxRG7EH9KKTVWKZWklCpVSh1RSn2nlOp3ofente4ipS5skRS7sAtKqQeBd4BXgJZAGPAeMNTIXEIYwaaKXSk1UCm1WymVqZR63Og8lqSUaqOUWquUylBK7VBK3W90JqMopUxKqRSl1MrGj/2AF2iYNvlCa12mta7RWn+ttX5EKeWmlHpHKZXb+OcdpZRb4/cGKqVWKqWKlFKFSql1Simnxq/tV0pd1fj355VSS5VSHymlTjb+DBJPy9RaKbVMKZWvlMpWSt3XhM/fXyn1uVJqV+O/hz5N9VjWSin1QOPPIF0ptVgp5W50JmtiM8WulDIBM4FBQGdgjFKqs7GpLKoWeEhrHQ30Bu52sOd/uvuBjNM+7gO4A8vPcPunaHjNYoHuQE/g6cavPQTk0HCRXUvgSeBMbzxdDywB/IGvgHcBGv8j+BpIA0KAAcBUpdRZL9a7QNOAVVrrKBqeT8ZZbm9XlFIhwH1AotY6BjABo41NZV1spthp+GXM1Fpnaa2rafgFc5jDbK31Ea311sa/n6ThlznE2FSWp5QKBQYDc077dABQoLWuPcO33Qy8oLXO01rnA/8Axjd+rQZoRcMVfTVa63X6zGcUrNdaf6u1rgMW0lCqAD2AIK31C1rraq11FjCbJigbpZQv0B+YC9D4eEXmfhwb4Ax4KKWcAU8g1+A8VsWWij0EOHTaxzk4YLEBKKUigDhgk7FJDPEO8CgNG7ycchwIbPwl/zOt+eMSFgcaPwfwOpAJfK+UyjrLFN/R0/5eDrg3PmY40LpxOqdIKVVEw8i/5bk+qfPQDsgHPmycjpqjlPJqgsexWlrrw8AbwEHgCFCstf7e2FTWxZaK/c8WxHa4czWVUt7AMmCq1rrE6DyWpJQaAuRprZP/60sbgEpg2Bm+NZeG8j0lrPFzaK1Paq0f0lq3A64DHlRKDTjPaIeAbK21/2l/fLTW157n/ZwLZyAe+LfWOg4oAxzt/aZmNBytt6XhP2gvpdQ4Y1NZF1sq9hygzWkfh+Jgh19KKRcaSn2R1voLo/MY4BLgeqXUfhqm4q5USn2stS4GngVmKqWGKaU8lVIuSqlBSqnXgMXA00qpIKVUYONtP4aG/yyUUh1Uw04aJUBd45/zsRkoUUo9ppTyaHxzN0Yp1cMsz/qPcoAcrfWpo7XPaSh6R3IVDf+R5muta4AvgL4GZ7IqtlTsW4BIpVRbpZQrDfOXXxmcyWIai2cukKG1fsvoPEbQWj+htQ7VWkfQ8PP/SWs9rvFrbwEP0vCmaD4No+h7gC+Bl4AkYBuwHdja+DmASOBHoJSGkf9753vueuOc+3U0vDmbTcOKg3MAvwt8qn/1WEeBQ0qpTo2fGgDsNPfjWLmDQO/G/8AVDa+BQ72BfDY2deWpUupaGuZYTcA8rfXLBkeymMYLbdbRUEyn5pc+jX+WAAAcQUlEQVSf1Fp/a1wq4yilLqdhA/UhRmexNKVULA3/cbgCWcCtWusTxqayLKXUP4BRNJwtlgLcrrWuMjaV9bCpYhdCCHF2tjQVI4QQ4hxIsQshhJ2RYhdCCDtzpgs6mlRgYKCOiIgw4qGFEMJmJScnF5zLnqdmKXal1Dzg1MUjMWe7fUREBElJSeZ4aCGEcBhKqQNnv5X5pmLmAwPNdF9CCCEugllG7FrrXxvXL2lSGUdKyD9Zhb+nC34eLjT3csXH3aWpH1YIm3GirJr80irKqmqpqG64gDbQx40gbzf8PFxwcvqzlTmEvbHYHLtSajIwGSAsLOyC7uPjjQdYtOngHz4X1tyTbqF+xLbx54qoFrQP8r7orELYAq012w8X8+POY2w7XEzGkRKOlZz5Gh03Zye6h/qTENGMHhHN6Ns+EHcXkwUTC0sx2wVKjSP2lecyx56YmKgvZI49t6iC3KIKisprKK6o4WhJJdtzitmWU0RucSUAXVr7cl331twQF0JLX1l7X9ifzLyTLNp0kNXpR8ktrsTkpIhs4U10K1+iW/nQys8DbzdnPF1N1GsoKK2ioLSKg4XlbD1wgh25JdTWa3zcnLm2aytuiA+hZ0RzGc3bAKVUstY68ay3s6Vi/yu5RRV8l36Ur9NyST1UhKvJiRsTQrijf3siAh1qVVNhh7TWbMouZPavWazZlYersxP9I4MYGBPMgKgWNPNyPef7qqiuY8v+Qlak5vJd+hHKq+vo2NKb+wZEcm1MKyl4K+ZwxX66/QVlzFmfxdKkHGrr6hkWG8Ljg6JoISN4YYMyjpTwwtc72ZB1nOZertzSJ5zxvcMJ8Ha76Psur67lu+1H+fcv+8jMKyWyhTcPXt2RgTHBNKyvJayJRYtdKbUYuBwIBI4Bz2mt557p9k1d7KfklVQyZ30283/fj6vJiQeu7siEPuE4m+S6LGH9TpRV89YPe1i06QC+Hi5MHRDJ6J5hTTIvXlev+Xb7Eaav2cvevFIu6xjES8NiaNPc0+yPJS6cxUfs58NSxX7K/oIynvtqB7/syScq2Id3RscSFexrsccX4nyt3ZXHI5+ncaK8hnG9wnjg6o74e577dMuFqqvXfLRhP2+s3k2d1tw/oCOT+7fDJNMzVkGK/b9orVm94xjPrEinuKKGpwdHM753uBxuCqtSUV3HK99msHDjAaKCfXh7VCzRrSw/CDlSXMFzK3bw/c5j9G7XnGmj4+RkBCsgxX4GBaVVPPxZGj/vzueq6Ja8MbKbRUZCQpxNVn4pkxcmk5lXyu392vLIwE64ORt3OqLWms+Tc3h2xQ48XU28PSqW/h3PejW7aELnWuwON9kc6O3GvAk9eGZIZ37Zk8cN7/1OVn6p0bGEg/tlTz5DZ/5GYVk1H0/qxdNDOhta6gBKKUYmtuGrey4hwNuVCR9uZubaTGQPB+vncMUO4OSkmNSvLZ/8vTfFFTXc8N7v/J5ZYHQs4YC01sxZl8WtH24mxN+DFXdfQr/IQKNj/UFkSx9W3N2P67q15vXVu3ls2TZq6urP/o3CMA5Z7Kf0iGjOirsvoaWvG7fM28zSLYeMjiQcSH295h9f7+SlbzK4pnMwy6b0tdqzUDxcTUwbHct9V3ZgaVIOEz/cTHFFjdGxxBk4dLEDtGnuybIpfenTPoBHl21j7vpsoyMJB1BTV89Dn6Ux//f9TOrXlvdujsfLzZBVtM+ZUooHr+nEGyO7szm7kNGzNnK8VLYZtUYOX+wAPu4uzJmQyKCYYF5cuZPpa/bKPKJoMpU1dUz5OJnlKYd5+JqOPD042qau9hyREMqcCT3Iyi9l1KyN5JVUGh1J/Bcp9kZuziZmjInjxvhQ3vphD69+t0vKXZhdZU0df/8oiTW78nhxWAz3XBlpk6fcXtYxiPm39iS3qIKbPtjA4aIKoyOJ00ixn8bZ5MTrI7oxvnc4H/yaxVs/7DE6krAj1bX13LVoK+v2FvCvGxv+ndmyPu0DWDipF8dLqxk9awNHi2Xkbi2k2P+Lk5PiH9d3YVRiG2b8lMnMtZlGRxJ2oKaunns+2cpPu/J45Yau3JTYxuhIZpEQ3oyFt/eisLSacXM3yZy7lZBi/xNOTopXhndlaGzD6V3z5A1VcRHq6zUPLU3j+53H+Mf1XRjb68L2I7BWsW38mTuxB4cKy7ll3mZKKuVsGaNJsZ+ByUnx5sjuDOwSzAsrd7Ii9bDRkYQN0lrz4jc7+Sotl8cGRjGhb4TRkZpE73YBvD8+gT3HTjJp/hYqa+qMjuTQpNj/grPJiWljYundrjkPf5bGb3IRkzhPs37N4sPf9nPbJW2587J2RsdpUld0asE7o+JIOnCCqUtSqauXkw+MIsV+Fm7OJj4Yn0i7QG/uXJhMxpESoyMJG7E8JYd/freLId1a8fTgaJs8++V8De7WimcGd2bVjqO8/E2G0XEclhT7OfDzcOHDW3vg5ebMxA83kyundomz2Jh1nEc+20afdgG8eVN3mzpP/WLd1q8tt13Slnm/ZcsFfwaRYj9Hrf09mH9bD8qq6rh9QRLl1bVGRxJWan9BGXd+nEx4gCfvj08wfDEvIzw1OJqBXYJ56ZudfL/jqNFxHI4U+3mICvZl+phYMo6W8NDSNOplDlH8l+KKGiYt2ALA3Ak98PNwMTiRMUxOindGx9It1J+pn6ay66hMYVqSFPt5ujKqJU8Oiua79KO886NcwCT+X23jueoHC8t5f1yCw2+i7u5iYtb4BLzdnLl9QZKc425BUuwX4PZL2zIyIZTpP2XydVqu0XGElXj1u12s21vAS8Ni6N0uwOg4VqGlrzuzbkkk72QVUxZtpbpWlvu1BCn2C6CU4uUbupIY3oxHP98mh5mCFamHmbM+mwl9whnVw74uQLpYsW38ee3GbmzOLuTFlTuNjuMQpNgvkKuzE+/dHI+PuzN3LEyWtakd2M7cEh5bto2eEc15ekhno+NYpWFxIUzu346FGw+wLDnH6Dh2T4r9IrTwdeff4+LJLarggU9T5c1UB1RUXs0dHyfh7+HKzJvjcTHJr9SZPPq3TvRpF8CTy7ezI7fY6Dh2Tf4VXqSE8OY8O6QzP+3KY9qavUbHERZUX6+Z+mkqx4qr+Pe4eIJ83IyOZNWcTU7MGBtHM09X7vw4maLyaqMj2S0pdjMY1zuc4fEhTP9pL7/uyTc6jrCQ937O5Ofd+TxzXWfiwpoZHccmBHq78d64eI4WV8pRbhOSYjcDpRQvD+tKxxY+TP00lSPFcmWqvfs9s4C3ftjD0NjWjLOz1RqbWnxYM569rgtrd+fz/q/7jI5jl6TYzcTD1cTMm+Opqqnj3k9SZBd3O3aspJL7lqTQLsibV27o6hBrwJjbuF5hDOnWijdW72ZT1nGj49gdKXYz6tDCm1eGdyXpwAleX73b6DiiCdTW1XPv4hTKqur4tw1sQG2tlFL8c3hXwgO8uHdxCgVy8ZJZSbGb2dDYEMb1DmPWr1n8tOuY0XGEmU1fs5fN2YW8fEMMkS19jI5j03zcXZg5Np7iihqZbzczKfYm8PTgznRu5ctDS9Nkvt2O/JZZwIy1mYxMCGV4fKjRcexC59a+/OP6LqzbW8C/f5H5dnORYm8C7i4m3h0bR1VtPfcvTqVW5tttXv7JKu5fkkr7IG/+MbSL0XHsyqgebbiue2ve+mEPSfsLjY5jF6TYm0i7IG9eGhbD5v2FTJfz221afb3mwaWpnKys4d2xcXi6yry6OSmleOWGGEL8PbhvcYqc324GUuxNaHh8KCMSQpmxNpPf98m2erZq1ros1u0t4LnruhAV7Gt0HLvk4+7Cu2PjyC+t4tHPt6G1zLdfDCn2JvbC0C60DfTigU9TKSyTkYitSTl4gjdW72Zw11aM6dnG6Dh2rVuoP48NjOL7ncdYuPGA0XFsmhR7E/N0dWb66DhOlNXw6OdpMhKxISWVNdy3JIWWvu68MlzOV7eE2y5py+WdgnjpmwxZNfUiSLFbQEyIH48PiuLHjDw+2iAjEVugtebp5enkFlUyfUysw+6EZGlOToo3RnbH192F+xanUFFdZ3QkmyTFbiG3XhLBlVEtePnbDDKOyEjE2i3bepiv0nK5f0AkCeHNjY7jUAK93Xjrpu7sOVbKS9/I+u0XwizFrpQaqJTarZTKVEo9bo77tDdKKV4f0Q0/DxfulZGIVcsuKOPZFen0atucu6/oYHQch9S/YxB39G/Hok0HWZUum2Gfr4sudqWUCZgJDAI6A2OUUrLbwJ8IaByJZObJSMRaVdfWc/+SFFxMTrw9KhaTk8yrG+WhazrRLdSPx7/YJhf6nSdzjNh7Apla6yytdTWwBBhqhvu1S5dGykjEmr35w2625RTzrxu70drfw+g4Ds3V2Ylpo+Oorq1n6pJU6mTJgXNmjmIPAQ6d9nFO4+f+QCk1WSmVpJRKys937DXLH7qmE11DZCRibdbvLeCDX7IY2yuMgTHBRscRQNtAL/5xfRc2ZRfyviw5cM7MUex/dqz6P/+1aq1naa0TtdaJQUFBZnhY2+Xq7MT0MQ0jkQc+lZGINTheWsUDS1Pp0MKbZwbLTKI1GZEQ+p8lB7YePGF0HJtgjmLPAU6/ciMUyDXD/dq1UyORjVkyEjGa1ppHPt9GcUUNM8bE4eFqMjqSOI1SipeGxRDs6879S1IoqZSN48/GHMW+BYhUSrVVSrkCo4GvzHC/dk9GItZhwe/7+WlXHk8MiiK6lSwZYI38PFyYPiaW3KJKnl6eLhf6ncVFF7vWuha4B1gNZABLtdY7LvZ+HYFSipdviKGVnzv3LZaRiBEyjpTwyne7uDKqBRP7RhgdR/yFhPDmTB0QyVdpuSzbetjoOFbNLOexa62/1Vp31Fq311q/bI77dBS+7i5MGx3HkWIZiVhaeXUt9y5Owc/DhddHdJMlA2zAXVd0oFfb5jy7Ip2s/FKj41gtufLUCiSEN/vPSOSz5Byj4ziMF77eyb78Ut6+KZYAbzej44hzYHJSvD0qFheTE/ctSaG6VvY6+DNS7Fbiris60Ltdc55bsYPMPBmJNLWv03JZsuUQd17Wnn6RgUbHEeehtb8Hr43oRvrhEl5btcvoOFZJit1KmJwU00Y3nJFxzydbqayRJQeayqHCcp78YjtxYf48eHVHo+OIC/C3LsHc0iecOeuzZW/hPyHFbkVa+rrzxshu7Dp6kn9+m2F0HLtUU1fPvYtTQMH00XG4mORXwFY9eW000Y17Cx8trjQ6jlWRf9VW5sqolkzq15YFGw6wKv2I0XHszuurd5N6qIhXh3ejTXNPo+OIi/CHvYWXpMiFfqeRYrdCjw2MonuoH498vo1DheVGx7EbP+06xqxfsxjXO4zB3VoZHUeYQfsgb14YGsOm7EKmyd7C/yHFboVcnZ14d2w8APd8slXe+TeD3KIKHlyaRudWvjwtSwbYlREJodwYH8qMn/aybq9jr0N1ihS7lWrT3JPXR3QnLaeYf34n8+0Xo6aunvsWp1BTW8/Mm+Nxd5ElA+zNi8O60CHIm6lLUjlWIvPtUuxWbGBMMLdeEsGHv+3nu+0y336hXlu1i6QDJ3hleFfaBnoZHUc0AU9XZ967OZ7y6jruXZxCbZ1jH+VKsVu5JwZF072NP498vk2utLsAq9KPMHtdNuN7hzM09n9WkxZ2JLKlDy/fEMPm7ELe+H6P0XEMJcVu5VydnXjv5nhcTIopH2+lvLrW6Eg2Iyu/lIc/20b3Nv48PSTa6DjCAobHhzKmZxjv/7LPoTeykWK3ASH+HkwfE8eevJM88cV2WU/mHFRU13HXoq24mBTv3RyPm7PMqzuK56/vTPdQPx7+LM1hj3Kl2G3EpZFBPHR1R1ak5rLg9/1Gx7FqWmseW7aN3cdO8s7oOEJkizuH4uZs4r1xCbiYFHd+nExZleMd5Uqx25C7Lu/AVdEteOmbDDbsO250HKs169csvkrL5eFrOnFZR8ferctRhfh7MGNMPJl5pTy6bJvDHeVKsdsQJyfFW6NiCQ/w5O5PtsrFS3/ilz35/GvVLq7tGsxdl7c3Oo4wUL/IQB4dGMU3244wc22m0XEsSordxvi6uzD7lkRq6uqZvDBZ3kw9zf6CMu79ZCsdW/rw+ojusr664I7+7RgW25o3vt/D9zsc581UKXYb1C7Imxlj4th9tIRHPttGvayRQXFFDZMWbMHJSTFrfCJebs5GRxJWQCnFqzd2o1uoHw98msruoyeNjmQRUuw26vJOLXh8UBTfbD/Cmz/sNjqOoWrq6rlrUTIHC8t5f1wCYQGyuJf4f+4uJmaNT8TTzZlJC7aQf7LK6EhNTordhv390naM6RnGzLX7WLrlkNFxDKG15pkv0/kt8zj/HN6N3u0CjI4krFCwnztzbkmkoLSK2z9KoqLavvc7kGK3YUopXhjahUsjA3ly+XbW7y0wOpLFffBrFku2HOKeKzowIiHU6DjCinVv48/00XFsyyniPjtf5leK3ca5mBquTO3QwpspHyezM7fE6EgW88XWHF79bheDu7WSnZDEObmmSzDPDenMDzuP8eLKnXZ7GqQUux3wcXdh3sQeeLs7c8u8zewvKDM6UpP7adcxHvl8G33bB/DWTd1xcpIzYMS5mXhJW27v15b5v+/nvZ/3GR2nSUix24nW/h4snNSTuvp6xs3dZNdbhSUfKOSuRVuJbuXDB+MTZLkAcd6evDaaG+JCeH31bru8kluK3Y50aOHDgtt6cqKsmlvmbeJEWbXRkcwu/XAxt81PopWfB/Nv7YmPu4vRkYQNcnJSvD6iG1d3bslzX+1gWXKO0ZHMSordznQL9Wf2hET2Hy/n5jmbKLSjck8/XMzNczbh7ebMR7f1JNDbzehIwoY5m5yYMSaOSzoE8OiybXyzzX72PJBit0N92wcy+5ZE9uWXMnb2Ro6X2v55uztyixk3t6HUl0zuLRtRC7M4dY57fJg/9y7eyvIU+xi5S7Hbqcs6BjF3Qg+yC8oYM3ujTV+UsT2nYaTu6WJi8d+l1IV5ebk5M//WnvRqG8CDS9Ps4poQKXY71i8ykA8n9uBgYTk3fbCBA8dt72yZX/fkM2rWBrxcnVkyuY9cVSqahJebM/Mm9qBfh0AeXbaN+b9lGx3pokix27m+HQJZdHsvTpRXM/y930k7VGR0pHP2Zcphbpu/hfAAL5bf1VdKXTQpD1cTs29J5OrOLXn+6528tHKnza7DJMXuABLCm7NsSl88XE2MnrWRNRnHjI70l7TWzFybydRPU0mMaMand/Smha+70bGEA3B3MfH+uAQm9o1gzvps7lq01SaXH5BidxDtg7z54q6+dGjhze0fJTHtx71WORopraplysdbeX31bq7v3pr5t/bEV05pFBZkclI8f30XnhnSmdU7jzJq1gab2/tAit2BtPBx59M7ejMsNoS3f9zDbQu2UFRuPadD7ssvZdjM3/gh4xhPD45m2uhY3F3k4iNhjEn92vLBuASy88sYPH2dTa3nLsXuYDxdnXnrpu68NCyG3zOPM3j6en7LNHbxsPp6zYLf9zNk+noKy6pZOKknt1/aTjbKEIa7pkswK+/rR1iAJ5MXJvPiyp1U1lj/1IwyYhGcxMREnZSUZPHHFX+UeqiIBz5NbTglsmcbnrg22uLTHocKy3ls2TZ+33ec/h2D+NeNXWnlJ5tPC+tSVVvHy99k8NGGA7QN9OKVG7rSp73ll4hWSiVrrRPPejspdsdWWVPH2z/sYfa6LFr4uPPYoE5c3z0EUxMvqlVWVcusX7OYvS4LBTw9pDOje7SRUbqwauv3FvDk8u0NpxAnhvLI36II8rHcFdBS7OK8pB0q4snl29mRW0JUsA8PX9OJAdEtzF60VbV1LEs+zNs/7iH/ZBWDu7bi8UFRctGRsBkV1XVMW7OX2euycDEpJvSJYHL/dgRYYIkLixS7Umok8DwQDfTUWp9TW0uxW6f6es0324/w1g97yC4oIyrYh7G9whgaG4Kfx8VN0RwpruCTTQdZvPkgBaXVJIY348nB0cSHNTNTeiEsK7ugjBlr9vJl6mHcXUyMSAhlZEIbYkJ8m+zI01LFHg3UAx8AD0ux24eaunqWbz3Mgg372ZFbgruLE1d3DubSDoH07RBAaLOzj6611mTmlfLz7nzW7s5jU3Yh9VozIKoFt/SJ4NLIQJl2EXYhM6+UmWsz+Wb7Eapr64kK9mFIt1b0ahdAt1A/sy4rbdGpGKXUz0ix26XtOcV8svkgP+w8RkHjYmIh/h6EB3jSppknrfzdMSlFvYa6+noOF1WSXVBKVkEZReU1AHRs6c1V0S0Z0zNMplyE3Sour+Hrbbl8lpzznyu8XZ2d6NLal9b+HgT7utPS141BMa0u+PfA6opdKTUZmAwQFhaWcODAgYt+XGE5Wmv2HCvlt8wCUg4VcaiwnJwTFf8p+1OCfd1pG+hF2yAvurT25fJOLQjxl7NchGMpLKsmaX8hm7MLSc8t5lhJFUeLK6moqePjSb3oFxl4QfdrtmJXSv0IBP/Jl57SWq9ovM3PyIjdIdXU1QNgUgqlkOkVIc5Aa01pVS2uzk4XPD1zrsXufA5hrrqgBMIhuJjkGjchzoVSymI7fslvpRBC2JmLKnal1A1KqRygD/CNUmq1eWIJIYS4UIZcoKSUygcu9N3TQMDYxU2MJ6+BvAaO/vzBMV+DcK110NluZEixXwylVNK5vHlgz+Q1kNfA0Z8/yGvwV2SOXQgh7IwUuxBC2BlbLPZZRgewAvIayGvg6M8f5DU4I5ubYxdCCPHXbHHELoQQ4i9IsQshhJ2xqWJXSg1USu1WSmUqpR43Oo8lKaXaKKXWKqUylFI7lFL3G53JKEopk1IqRSm10ugsRlBK+SulPldK7Wr899DH6EyWppR6oPH3IF0ptVgp5W50JmtiM8WulDIBM4FBQGdgjFKqs7GpLKoWeEhrHQ30Bu52sOd/uvuBDKNDGGgasEprHQV0x8FeC6VUCHAfkKi1jgFMwGhjU1kXmyl2oCeQqbXO0lpXA0uAoQZnshit9RGt9dbGv5+k4Zc5xNhUlqeUCgUGA3OMzmIEpZQv0B+YC6C1rtZaFxmbyhDOgIdSyhnwBHINzmNVbKnYQ4BDp32cgwMWG4BSKgKIAzYZm8QQ7wCP0rBzlyNqB+QDHzZOR81RSnkZHcqStNaHgTeAg8ARoFhr/b2xqayLLRX7ny307XDnaiqlvIFlwFStdYnReSxJKTUEyNNaJxudxUDOQDzwb611HFAGONr7Tc1oOFpvC7QGvJRS44xNZV1sqdhzgDanfRyKgx1+KaVcaCj1RVrrL4zOY4BLgOuVUvtpmIq7Uin1sbGRLC4HyNFanzpa+5yGonckVwHZWut8rXUN8AXQ1+BMVsWWin0LEKmUaquUcqXhzZKvDM5kMapha6K5QIbW+i2j8xhBa/2E1jpUax1Bw8//J621Q43UtNZHgUNKqU6NnxoA7DQwkhEOAr2VUp6NvxcDcLA3kM/mrDsoWQutda1S6h5gNQ3vgs/TWu8wOJYlXQKMB7YrpVIbP/ek1vpbAzMJY9wLLGoc4GQBtxqcx6K01puUUp8DW2k4WywFWV7gD2RJASGEsDO2NBUjhBDiHEixCyGEnZFiF0IIOyPFLoQQdkaKXQgh7IwUuxBC2BkpdiGEsDP/BwhV8/ssWIDfAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.arange(0, 3 * np.pi, 0.1)\n",
    "y_sin = np.sin(x)\n",
    "y_cos = np.cos(x)\n",
    "\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.plot(x, y_sin)\n",
    "plt.title('Sine')\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.plot(x, y_cos)\n",
    "plt.title('Cosine')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 图片\n",
    "可以使用 **imshow** 函数来显示一张图片"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import imageio\n",
    "\n",
    "img = imageio.imread('assets/cat.jpg')\n",
    "img_tinted = img * [1, 0.95, 0.9]\n",
    "\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.imshow(img)\n",
    "\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.imshow(np.uint8(img_tinted))\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
